Addendum to Tardiness Bounds for Global EDF with Deadlines Different from Periods

In Tardiness Bounds for Global EDF with Deadlines Different from Periods [1], provided tardiness bounds for the global Earliest Deadline First (EDF) scheduling algorithm which are the tightest known in the case of arbitrary deadlines, in which deadlines need not be equal to periods. However, in some cases it is possible to develop even tighter bounds. In this technical report we describe this technique and provide an initial experimental appraisal. In [1] we provided, with proof, tardiness bounds that could be used to analyze the global Earliest Deadline First (EDF) scheduler even in the case in which deadlines and periods differ. We did so by providing an extra term Si for each task which can be roughly indicated as the extra tardiness that could be created due to a task being due early. In [1] we statically defined this number purely based on the task parameters. However, this technique is more conservative than necessary in some cases. In this report, we will refer heavily to the theorems, lemmas, and proofs presented in [1]. Observe that the values Ui and Si are used in Theorem 1 only for the purpose of upper-bounding dbf(τi, t). Lemma 1 proved that using Ui = Ci Ti (i.e., utilization) and Si = Ci × max { 0, 1− Di Ti } are sufficient to produce tardiness bounds. However, any values of Vi and Si such that dbf(τi, t) ≤ Vit+ Si (1) holds can play the same role in the proof of Theorem 1, and provide bounded tardiness under the assumption that ∀τi, Vi ≤ 1 and ∑ τi∈τ Vi ≤ m. We can then obtain tardiness bounds by replacing Ui with Vi in Definition 1 and finding a minimal compliant vector as before. It is trivial to observe that if Vi < Ui, then (1) cannot hold. Thus, the bounds cannot be improved by decreasing Vi. However, if we increase Vi, we can reduce the corresponding Si term. Of course, due to the conditions for bounded tardiness above, this is only possible if the system is not fully utilized. Using a method similar to the proof of Lemma 1, one can demonstrate that Si = max {0, Ci − ViDi} provides the smallest value such that (1) holds. We have performed simple experiments which demonstrate that in some cases, tardiness bounds can be improved by increasing Vi and decreasing Si. 2 J. Erickson, N. Guan, S. Baruah The most obvious case is when a value does not contribute to L(x) but does have a nonzero Si value. In this case, we may increase Vi at least to the minimum value it would require to contribute to L(x), and S(τ) will be decreased with no increase to L(x), resulting in smaller bounds for all tasks. In some other cases, the increase to L(x) caused by increasing Vi is less than the decrease to S(τ), which also leads to smaller tardiness bounds. Therefore, for many task systems which are not fully utilized, improvements to the bound are possible. However, we have not yet found an efficient method for determining the smallest possible tardiness bounds for a given task set. We instead use Algorithm 1 below to find an improvement which is not guaranteed to be optimal. We observe in light of Lemma 5 that minimizing L(x) + S(τ) is sufficient to minimize the overall tardiness bounds. Algorithm 1 starts by using the initial L(x)+S(τ) as in Theorem 1, which can be computed exactly using Algorithm 1. We then iterate, using the variable i to track whether an improvement has been made. We use one parameter, j, which specifies the desired step size by which to increase each Vi value. We increase by less than j in cases where increasing by j either violates the conditions for bounded tardiness or is clearly suboptimal (i.e., when Vi = Ci Di , Si = 0 so no further increase is desirable.) We attempt to increase Vi for each task independently, and actually increase Vi for whichever task leads to the largest decrease in L(x) +S(τ). Iteration terminates whenever no improvement was made during one iteration, or when ∑ τi∈τ Vi reaches m. In order to determine the validity of this approach, we generated a random set of constrained-deadline (Di ≤ Ti) task systems. Each set of 1000 tasks was determined by parameters m, the number of CPUs, Umax, the maximum possible utilization for a given task, and Utot, the total utilization of all tasks. Task utilizations Ui were selected uniformly from the range [0, Umax], periods Ti uniformly from [5, 30], and deadlines uniformly from [0, Ti]. Tasks were generated until ∑ Ui > Utot − Umax, at which point a task of utilization Utot − ∑ Ui was created to achieve Utot exactly. Tasks were generated with Utot ranging from m − .9 to m − .1 in increments of 0.1, with Umax values of 0.1, 0.5, and 1, and with m values of 4, 8, and 16. Experiments were performed on each task set using Algorithm 1 with a simple binary search algorithm in place of Algorithm 1 to compute L(x) values. The binary search algorithm runs very quickly at the expense of providing only an approximate solution. Algorithm 1 was run both with j = 1 (in which case each Vi was increased as much as possible or not at all) and with j = 0.1. Experiments ran noticeably faster for j = 1, because many fewer iterations were required. However, utilizing j = 0.1 produced marginally better improvements. This demonstrates that increasing several Vi values each by less than the full amount can be better than increasing a smaller number of Vi values. Results are shown in Figures 1(a), 1(b), and 1(c). Several trends immediately appear. For task sets with small values of Umax, having a larger difference between m and Utot leads to more significant improvements. This is unsurprising, because larger differences between m and Utot allow for greater increases in Vi values. In the extreme case where Utot = m our technique would provide absoTitle Suppressed Due to Excessive Length 3 1: for all τi ∈ τ do 2: Vi = Ui 3: Si = Ci ×max { 0, 1− Di Ti } 4: end for 5: b = initial best L(x) + S(τ) value 6: i = 1 7: while i = 1 AND ∑ τi∈τ Vi < m do 8: i = 0 9: k = min{j,m− ∑ τi∈τ Vi} 10: for all τi ∈ τ do 11: Vi = min { 1, Ci min{Di,Ti} , Vi + k } 12: Si = max {0, Ci − ViDi} 13: c = best L(x) + S(τ) value for τ 14: if c < b then 15: b = c 16: i = 1 17: end if 18: Restore Vi and Si to previous values 19: end for 20: if i = 1 then 21: Update Vi and Si to match most recent b value 22: end if 23: end while Algorithm 1: Algorithm to determine improved bound by altering Vi and Si 4 J. Erickson, N. Guan, S. Baruah